The spell is done in 5 different Niagara systems:

1. Prepare
2. Aim
3. Pre-Cast
4. Cast
5. Hit
6. Hit_Floor

All of them are made up of carefully timed sprites, meshes animated with WPO-materials, as well as animated Houdini-geometry imported via Vertex Animation Textures.

Materials

This radial noise material I could use for multiple parts of the effect. First, I mirrored the UVs, so I wouldn't get that hard anti-aliasing line. Then I overlayed the radial UVs with a slight distortion noise. Finally, I set the material up to work with color curves, so I would be able to easily fine-tune the look of the effect.

Another material worth mentioning was this shockwave material. In my workflow, I like to pack different variants of a texture into the different color channels. Inside the material, I can switch variants by setting a float parameter. By limiting my use of Static-Switch parameters, I can avoid shader permutations.

Houdini Meshes

I created a procedural chain animation in Houdini with VEX, and afterward imported it into Unreal via Vertex Animation Textures. The vertex colors on the chain are used inside the material to control the visibility.

I was very pleased with how the technique for the vertical shine of the rune outlines worked. I created the rune-mesh in Houdini by extruding an image-trace, and put information for timing and offset of the scrolling animation inside the vertex colors to be used inside the material.

The Red channel contains piece-information to offset the timing of the shine, the Green channel is a gradient in the y-axis, and the Blue channel feeds into the scrolling sine mask.

The particle simulation was pre-rendered in Houdini and brought into Unreal as an Alembic Cache. Originally, I tried to get it done using the Houdini Niagara plug-in, but the plug-in had some compatibility issues because I was working on a few different PCs.

There is much more to tell about this effect, I had a lot of fun exploring the different techniques and I am very proud of the result! I will happily explain a technique in more detail, if there are any questions!

Here is a rundown of how my VAT Veils tool is built.

The base functionality of the tool is:

1. generate a cloth mesh on an unreal-spline
2. cache out a "floating" 200-frame cloth simulation, make it loopable
3. generate Vertex Animation Textures from that animation
4. import the Vertex Animation Textures into Unreal, create a Material Instance and assign everything correctly so the user only has to drag the mesh into the scene

The goal for this tool was to find a way to automate the tedious process of creating, importing and and setup of the VATs. To accomplish this, I integrated the HDA inside an Editor Utility Widget (EUW), using the Houdini Public API. From within the EUW, I can instantiate the HDA, set inputs and parameters, and run a python script that handles the VAT-setup. This also had the added benefit of providing a very clean UI, without the usual clutter that you need to scroll past when you use an HDA as it is. 

Houdini:

The Houdini-part is relatively straight forward. The cloth mesh gets deformed onto the input-curve, and has a simple noise animation applied to it. The middle-part of the cloth mesh is pinned in place, then it gets fed into a vellum simulation.

Animated Noise VOP:

Loopable Vellum simulation:

The vellum simulation runs for 200 frames, and is looped into a 100-frame animation. In Unreal, only a preview mesh is visible, which shows the resolution via the vertex color.

Editor Utility Widget:

Inside the EUW, I created custom buttons for creating a Houdini Session, Instantiating the HDA, cooking the HDA, and generating the VATs. I also exposed parts of the Houdini Engine UI via the Details View Widget. Sadly enough, this Widget seems to be very buggy, and doesn't expose the parameters properly. I had some issues with it and I hope proper support gets added by Epic Games in the future. 

OnClicking the "Generate VATs" button, the hidden parameters for reseting the simulation and rendering the cache are executed. The only two parameters exposed to the user in this section, are the export path for the cache and VATs, and the cache version, which the user needs to set manually so as to not override previous caches.

After the cache has finished, the Vertex Animation Textures are being generated. To be able to access the rop network from inside Unreal, I had to add the Labs Export Node to an Editable Node in the HDA type properties. As a last step, after the generation of the VATs is done, my python script is executed, that handles the import and setup of the VATs.

I figured out a lot of valuable HDA-workflow-related tricks during this project. If anybody is interested in learning more about it, feel free to contact me!

I created this procedural HDA in the course of my master thesis about Houdini-Unreal integration. Here is a quick rundown of the different steps.

Houdini:

First, the tool takes the input-curves and runs a simple vellum simulation over it. In Unreal, the user can adjust the droopiness of the rope by changing the rope resolution, or choosing a later simulation frame via the timeshift node.

The tool contains several prepared clothing meshes, which can all be activated/deactivated by the user inside the engine.

For each of those clothing items, the width of the bounding box is stored inside a detail attribute.

Along every input curve, points are created along the curve. The distance of each point takes into account the width of a random clothing item. Then, the points are deformed along the curve and the respective clothing items are scattered on them. For a more detailed explanation on this technique, check out Viktor Anfimovs' tutorial on aligning objects along a curve in Houdini.

For an increased realistic look, you can run the scattered clothing through another vellum simulation, before baking the HDA. This should take about 30 seconds, but that depends on the number of clothing items and the simulation frame you select. However, when testing the HDA in Unreal with the wind material turned on, I found that this last step often isn't necessary to get a good look.

Unreal Material: Wind + Patterns

The wind for the Clothesline is controlled by the World Position Offset inside the material. It offers customization of the wind strength and wind direction based on the world space UVs. The wind strength is also multiplied by the green vertex color of the clothing items, so it affects the clothing stronger at the bottom. The different color tints are based on the value of the red vertex channel, the seed of which can also be customized inside the HDA.